function a(){
    const b = 1
    const c=()=>{
        console.log('是否形成闭包',b)
    }
    return c
}

const cf = a()
cf()

/**
 *
 一、全局代码加载与创建阶段（Global Creation）
创建“全局执行上下文”GEC。
创建“全局词法环境”LE_global：
环境记录（EnvRecord）：保存所有全局的函数声明、let/const 等绑定。
外部引用（Outer）：null。
函数 a 被放入 LE_global 的绑定中：a → FunctionObject_a，其内部槽 [[Environment]] = LE_global（函数定义时捕获的词法环境）。
此时并未执行 a()，只是把 a 放到全局可用。
二、执行 const cf = a()：进入 a 的执行上下文
1) 调用 a() 时，创建“函数执行上下文”FEC_a。
新建“词法环境”LE_a：
环境记录：将 b、c 的绑定创建（const/let 在创建阶段“未初始化”）。
外部引用（Outer）指向 a.[[Environment]]，也就是 LE_global。
确定 this（与闭包无关）：普通函数 a() 在严格模式下为 undefined，非严格模式下为全局对象。
2) 执行 a 函数体（执行阶段）：
执行 const b = 1：
在 LE_a 的环境记录中初始化并赋值 b = 1。
执行 const c = () => {...}：
创建箭头函数对象 FunctionObject_c：
箭头函数没有自己的 this/arguments 绑定，this 在定义时从外层捕获。
关键：c.[[Environment]] = LE_a（定义时捕获了创建环境），这一步确立了闭包的必要条件。
在 LE_a 中初始化并赋值 c = FunctionObject_c。
执行 return c：
返回 FunctionObject_c 到调用点。
3) a 的上下文准备退出：
按理 LE_a 将随 FEC_a 弹出而“不可达”，但此时返回的 c 被外部变量 cf 接住了。
因为 c.[[Environment]] 引用的是 LE_a，且 c 仍可达，故 LE_a 也随之被保留，形成闭包。
结果：cf = FunctionObject_c，并且 cf.[[Environment]] = LE_a，其中含有 b = 1。
三、执行 cf()：使用闭包
1) 调用 cf()，创建“函数执行上下文”FEC_c。
箭头函数的 this：来自“定义处”的外层（也就是 a 执行时的 this），与调用方式无关；不过本例不使用 this，不影响结果。
创建“词法环境”LE_c（若函数体里有块级绑定会用上；此例可忽略），其外部引用指向 cf.[[Environment]] = LE_a。
2) 解析标识符并执行：
执行 console.log('是否形成闭包', b)：
在 LE_c 查找 b：未找到。
沿作用域链到 Outer = LE_a：命中 b = 1。
输出：“是否形成闭包 1”。
这展示了“即使 a 已经返回，它的局部变量 b 仍可被 c 使用”的现象——这就是闭包。
 */